home *** CD-ROM | disk | FTP | other *** search
/ Mac Power 1997 December / MACPOWER-1997-12.ISO.7z / MACPOWER-1997-12.ISO / AMUG / PROGRAMMING / Raven 1.2.sit / Raven 1.2 / Source / Foundation / Common / ZMemUtils.cpp < prev    next >
Text File  |  1997-06-18  |  16KB  |  681 lines
  1. /*
  2.  *  File:       ZMemUtils.cpp
  3.  *  Summary:       Misc memory utilities.
  4.  *  Written by: Jesse Jones
  5.  *
  6.  *  Copyright ｩ 1996-1997 Jesse Jones. 
  7.  *    For conditions of distribution and use, see copyright notice in ZTypes.h  
  8.  *
  9.  *  Change History (most recent first):    
  10.  *
  11.  *         <3>     4/13/97    JDJ        Includes Gestalt.h
  12.  *         <2>     4/13/97    JDJ        TemporaryZone no longer caches zone.
  13.  *         <1>     1/14/96    JDJ        Created.
  14.  */
  15.  
  16. #include <ZMemUtils.h>
  17.  
  18. #include <Errors.h>
  19. #include <Gestalt.h>
  20. #include <Resources.h>
  21.  
  22. #include <ZDebug.h>
  23. #include <ZExceptions.h>
  24. #include <ZUnitTest.h>
  25.  
  26.  
  27. // ===================================================================================
  28. //    Helper Functions
  29. // ===================================================================================
  30.  
  31. //---------------------------------------------------------------
  32. //
  33. // LowestPossibleAddress
  34. //
  35. //---------------------------------------------------------------
  36. static void* LowestPossibleAddress()
  37. {
  38.     static void* address = &SystemZone()->heapData;
  39.     
  40.     return address;
  41. }
  42.  
  43.  
  44. //---------------------------------------------------------------
  45. //
  46. // HighestPossibleAddress
  47. //
  48. //---------------------------------------------------------------
  49. static void* HighestPossibleAddress()
  50. {
  51.     static void* address = nil;
  52.     
  53.     if (address == nil) {
  54.         long logicalRAM;
  55.         if (Gestalt(gestaltLogicalRAMSize, &logicalRAM) != noErr)
  56.             logicalRAM = 128*1024L*1024L;
  57.  
  58.         address = (void*) logicalRAM;
  59.     }
  60.     
  61.     return address;
  62. }
  63.  
  64. #pragma mark -
  65.  
  66. // ===================================================================================
  67. //    Allocation
  68. // ===================================================================================
  69.  
  70. //---------------------------------------------------------------
  71. //
  72. // CreatePtr
  73. //
  74. //---------------------------------------------------------------
  75. void* CreatePtr(ulong bytes, bool zeroBytes)
  76. {
  77.     void* ptr = nil;
  78.     
  79.     ptr = NewPtr(bytes);
  80.  
  81.     if (ptr != nil) {
  82.         if (zeroBytes)
  83.             SetMemory(ptr, 0, bytes);    
  84. #if DEBUG
  85.         else    
  86.             SetMemory(ptr, kNewFill, bytes);    
  87. #endif        
  88.     }
  89.  
  90.     return ptr;
  91. }
  92.  
  93.  
  94. //---------------------------------------------------------------
  95. //
  96. // DisposeIfPtr
  97. //
  98. //---------------------------------------------------------------
  99. void DisposeIfPtr(void* ptr)
  100. {
  101.     if (ptr != nil) {
  102.         ValidatePtr(ptr);
  103.  
  104. #if DEBUG
  105.         long size = GetPtrSize((Ptr) ptr);
  106.         SetMemory(ptr, kFreeFill, (ulong) size);
  107. #endif
  108.  
  109.         DisposePtr((Ptr) ptr);
  110.     }
  111. }
  112.  
  113.  
  114. //---------------------------------------------------------------
  115. //
  116. // ValidatePtr
  117. //
  118. //---------------------------------------------------------------
  119. #if DEBUG
  120. void ValidatePtr(void* ptr)
  121. {
  122.     if (ptr == nil)                                
  123.         DEBUGSTR("Ptr is nil.");
  124.                                     
  125.     else if (((long) ptr & 0x3) != 0)                             
  126.         DEBUGSTR("Ptr is not on a long-word boundary (%lX).", (long) ptr);
  127.                 
  128.     else if (ptr < LowestPossibleAddress())
  129.         DEBUGSTR("Ptr is too small (%lX).", (long) ptr);
  130.  
  131.     else if (ptr > HighestPossibleAddress())
  132.         DEBUGSTR("Ptr is too large (%lX).", (long) ptr);
  133. }
  134. #endif
  135.  
  136.  
  137. //---------------------------------------------------------------
  138. //
  139. // CreateHandle
  140. //
  141. //---------------------------------------------------------------
  142. Handle CreateHandle(ulong bytes, int options)
  143. {
  144.     Handle hand = nil;
  145.  
  146.     ASSERT(bytes < 16*1024L*1024L);
  147.     ASSERT((options & ~(kZeroBytes | kUseTempHeap | kUseAppHeap)) == 0);
  148.  
  149.     bool zeroBytes = (options & kZeroBytes)   == kZeroBytes;
  150.     bool tempMem   = (options & kUseTempHeap) == kUseTempHeap;
  151.     bool appHeap   = (options & kUseAppHeap)  == kUseAppHeap;
  152.     
  153.     if (tempMem) {
  154.         OSErr err;
  155.         hand = TempNewHandle((long) bytes, &err);
  156.     }
  157.     else
  158.         hand = NewHandle(bytes);
  159.  
  160.     if (hand != nil) {
  161.         ValidateHandle(hand);
  162.  
  163.         if (zeroBytes)
  164.             SetMemory(*hand, 0, bytes);    
  165. #if DEBUG
  166.         else    
  167.             SetMemory(*hand, kNewFill, bytes);    
  168. #endif        
  169.     }
  170.  
  171.     return hand;
  172. }
  173.  
  174.  
  175. //---------------------------------------------------------------
  176. //
  177. // DisposeIfHandle
  178. //
  179. //---------------------------------------------------------------
  180. void DisposeIfHandle(Handle hand)
  181. {
  182.     if (hand != nil) {
  183.         ASSERT(hand != GZSaveHnd());            // ensure we're not messing with the growzoneﾕs protected handle
  184.         ASSERT(!IsResource(hand));
  185.         
  186.         if (*hand != nil) {
  187.             ValidateHandle(hand);
  188.  
  189. #if DEBUG
  190.             ulong size = (ulong) GetHandleSize(hand);
  191.             SetMemory(*hand, kFreeFill, size);
  192. #endif
  193.             
  194.         } else
  195.             ASSERT(IsPurgeable(hand));
  196.             
  197.         ::DisposeHandle(hand);
  198.     }
  199. }
  200.  
  201.  
  202. //---------------------------------------------------------------
  203. //
  204. // ValidateHandle
  205. //
  206. //---------------------------------------------------------------
  207. #if DEBUG
  208. void ValidateHandle(Handle hand)
  209. {
  210.     if (hand == nil)                                
  211.         DEBUGSTR("Handle is nil.");
  212.                                     
  213.     else if (((long) hand & 0x3) != 0)
  214.         DEBUGSTR("Handle is not on a long-word boundary (%lX).", (long) hand);
  215.  
  216.     else if (hand < LowestPossibleAddress())
  217.         DEBUGSTR("Handle is too small (%lX).", (long) hand);
  218.  
  219.     else if (hand > HighestPossibleAddress())
  220.         DEBUGSTR("Handle is too large (%lX).", (long) hand);
  221.         
  222.     else if (*hand == nil)
  223.         /* can be purged */;
  224.  
  225.     else if (((long) *hand & 0x3) != 0)                             
  226.         DEBUGSTR("Master pointer is not on a long-word boundary (%lX).", (long) *hand);
  227.         
  228.     else if (*hand < LowestPossibleAddress())
  229.         DEBUGSTR("Master pointer is too small (%lX).", (long) *hand);
  230.  
  231.     else if (*hand > HighestPossibleAddress())
  232.         DEBUGSTR("Master pointer is too large (%lX).", (long) *hand);
  233.  
  234. #if 0                                                        // Spotlight doesn't like this code
  235.     else {
  236.         THz zone = HandleZone(hand);
  237.         OSErr err = MemError();
  238.  
  239.         if (err == noErr) {
  240.             if (zone == ApplicationZone()) {                // Temp memory doesn't appear to be a real zone...
  241.                 void* heapStart = &zone->heapData;
  242.                 void* heapEnd   = zone->bkLim;
  243.         
  244.                 if (hand < heapStart || hand >= heapEnd)
  245.                     DEBUGSTR("Handle is outside of heap.");
  246.                 else if (*hand < heapStart || *hand >= heapEnd)
  247.                     DEBUGSTR("Master pointer is outside of heap.");
  248.             }
  249.         } else
  250.             DEBUGSTR("Error %d calling HandleZone.", err);
  251.     }
  252. #endif
  253. }
  254. #endif
  255.  
  256. #pragma mark -
  257.  
  258. // ===================================================================================
  259. //    Handle State
  260. // ===================================================================================
  261.  
  262. //---------------------------------------------------------------
  263. //
  264. // IsLocked
  265. //
  266. //---------------------------------------------------------------
  267. bool IsLocked(Handle hand)
  268. {
  269.     ValidateHandle(hand);
  270.     
  271.     char state = HGetState(hand);
  272.     ASSERT(MemError() == noErr);
  273.     return (state & 0x80) != 0;
  274. }
  275.  
  276.  
  277. //---------------------------------------------------------------
  278. //
  279. // IsPurgeable
  280. //
  281. //---------------------------------------------------------------
  282. bool IsPurgeable(Handle hand)
  283. {
  284.     ASSERT(hand != nil);
  285.     
  286.     char state = HGetState(hand);
  287.     OSErr err = MemError();
  288.     
  289.     if (err == noErr)
  290.         return (state & 0x40) != 0;
  291.     else if (err == nilHandleErr)
  292.         return true;                                // Handle has been purged.
  293.     else
  294.         DEBUGSTR("Error %d in IsPurgeable.", err);
  295.         
  296.     return false;
  297. }
  298.  
  299.  
  300. //---------------------------------------------------------------
  301. //
  302. // IsResource
  303. //
  304. //---------------------------------------------------------------
  305. bool IsResource(Handle hand)
  306. {
  307.     ValidateHandle(hand);                // Might want to treat this like IsPurgeable.
  308.  
  309.     char state = HGetState(hand);
  310.     ASSERT(MemError() == noErr);
  311.     return (state & 0x20) != 0;
  312. }
  313.  
  314. #pragma mark -
  315.  
  316. // ===================================================================================
  317. //    Operations
  318. // ===================================================================================
  319.  
  320. //---------------------------------------------------------------
  321. //
  322. // ClearMemory
  323. //
  324. //---------------------------------------------------------------
  325. void ClearMemory(void* adr, ulong byteCount)
  326. {
  327.     Byte* destPtr = (Byte *) adr;
  328.     Byte* endPtr = nil;
  329.     unsigned long longSetVal = 0;
  330.     long* longEndPtr = nil;
  331.     long* longSetValPtr;
  332.  
  333.     endPtr = (Byte *) (destPtr + byteCount);
  334.  
  335.     longEndPtr = (long *) ((long) (destPtr + byteCount) & 0xFFFFFFFC);// Trunc to nearest 4 bytes
  336.  
  337.     // We do longword assignments when we have a chance
  338.     if (byteCount >= 4) {
  339.         while (((long) destPtr) & 0x00000003)            // Starting on an odd byte boundry
  340.             *destPtr++ = 0;
  341.  
  342.         // Assign in 4 byte chunks what we can
  343.         for (longSetValPtr = (long *) destPtr; longSetValPtr < longEndPtr;)
  344.             *longSetValPtr++ = 0;
  345.         destPtr = (Byte *) longSetValPtr;
  346.     }
  347.  
  348.     // Now finish assigning odd bytes
  349.     while (destPtr < endPtr)
  350.         *destPtr++ = 0;
  351. } 
  352.  
  353.  
  354. //---------------------------------------------------------------
  355. //
  356. // SetMemory
  357. //
  358. //    Much thanks for this improved version to Scott D. Schmitz (from MacApp)
  359. //
  360. //---------------------------------------------------------------
  361. void SetMemory(void* destPtr, Byte setVal, ulong byteCount)
  362. {
  363.     // here are the results of using chars (1), longs (4) or doubles (8) on 68K and PowerPC
  364.     //                 68K                601
  365.     //---------------------------------------
  366.     // char            261    (100)        237 (100)
  367.     // long            156    (60)        68     (29)
  368.     // double        933    (357)        46    (19)
  369.     //---------------------------------------
  370.     // the poor result for 68K/double is to be expected. Jeroen Schalk, DTS.
  371.  
  372. #if powerc
  373.     const unsigned long    kBytesPerPunch = 8;
  374.     typedef double        Punch, *PunchPtr;        // select type double for best performance
  375. #else
  376.     const unsigned long        kBytesPerPunch = 4;
  377.     typedef unsigned long    Punch, *PunchPtr;    // select type long for best performance
  378. #endif
  379.  
  380.     Byte *begPtr    = (Byte *) StripAddress(destPtr);
  381.     Byte *endPtr    = (Byte *) (begPtr + byteCount);
  382.  
  383.     // this looks like the right cutoff, since for the optimization 
  384.     // O(n) = kBPP + kBPP/2 + n/kBPP + kBPP/2 = 2*kBPP + n/kBPP
  385.     // a simple linear fill has O(n) = n
  386.     // n > 2*kBPP + n/kBPP if n > 2*kBPP, since 1/kBPP ﾅ 0.
  387.  
  388.     if (byteCount >= (4 * kBytesPerPunch)) {
  389.         // progress to nearest 4 byte boundary. O(n) = kBytesPerPunch/2
  390.         while ((long) begPtr & (kBytesPerPunch - 1))
  391.             *begPtr++ = setVal;
  392.  
  393.         // lets get a kBytesPerPunch byte 'punch'. O(n) = kBytesPerPunch
  394.         register PunchPtr punchSetValPtr = (PunchPtr)begPtr;    // save pointer to the first value
  395. #if powerc
  396.         *begPtr++ = setVal;                                        // fill it in
  397.         *begPtr++ = setVal;
  398.         *begPtr++ = setVal;
  399.         *begPtr++ = setVal;
  400. #endif
  401.         *begPtr++ = setVal;
  402.         *begPtr++ = setVal;
  403.         *begPtr++ = setVal;
  404.         *begPtr++ = setVal;
  405.         register Punch punchSetVal = *punchSetValPtr++;            // pick it up
  406.  
  407.         // truncate to nearest kBytesPerPunch bytes
  408.         PunchPtr punchEndPtr = (PunchPtr)((long) endPtr & (0xFFFFFFFF - (kBytesPerPunch - 1)));
  409.  
  410.         // assign in kBytesPerPunch byte chunks what we can. O(n) = n/kBytesPerPunch
  411.         while (punchSetValPtr < punchEndPtr)
  412.             *punchSetValPtr++ = punchSetVal;
  413.  
  414.         begPtr = (Byte *) punchSetValPtr;
  415.         }
  416.  
  417.     // now finish assigning odd bytes. O(n) = kBytesPerPunch/2 if optimization chosen.
  418.     while (begPtr < endPtr)
  419.         *begPtr++ = setVal;
  420.  
  421. }
  422.  
  423.  
  424. //---------------------------------------------------------------
  425. //
  426. // InvertMemory
  427. //
  428. //---------------------------------------------------------------
  429. void InvertMemory(void* adr, ulong byteCount)
  430. {
  431.     ASSERT(adr != nil);
  432.     ASSERT(byteCount > 0);
  433.  
  434.     Byte* ptr = (Byte *) adr;
  435.  
  436.     if (((ulong) ptr & 0x1) || (byteCount & 0x3)) {
  437.         TRACEFLOW("ZWarning", "InvertBlock(): warning - using slow method (odd pointer or byte count not % 4)¥n");
  438.  
  439.         Byte* bytes = (Byte *) ptr;
  440.  
  441.         while (byteCount--)
  442.             *bytes++ ^= (Byte) (~0x0);
  443.  
  444.     } else {
  445.         ulong* longs = (ulong *) ptr;
  446.         ulong longCount = byteCount >> 2;
  447.  
  448.         while (longCount--)
  449.             *longs++ ^= ~0x0;
  450.     }
  451. }
  452.  
  453. #pragma mark -
  454.  
  455. // ===================================================================================
  456. //    Bit twiddling
  457. // ===================================================================================
  458.  
  459. //---------------------------------------------------------------
  460. //
  461. // TestBit
  462. //
  463. //---------------------------------------------------------------
  464. bool TestBit(const void* bytePtr, ushort bit)
  465. {
  466.     ushort    index = (ushort) (bit >> 3);
  467.     ushort    mask = (ushort) (1 << ((bit & 0x07) ^ 0x07));
  468.  
  469.     return (((Byte *) bytePtr)[index] & mask) != 0;
  470. }
  471.  
  472.  
  473. //---------------------------------------------------------------
  474. //
  475. // SetBit
  476. //
  477. //---------------------------------------------------------------
  478. void SetBit(void* bytePtr, ushort bit)
  479. {
  480.     ushort    index = (ushort) (bit >> 3);
  481.     Byte    mask = (Byte) (1 << ((bit & 0x07) ^ 0x07));
  482.  
  483.     ((Byte *) bytePtr)[index] |= mask;
  484. }
  485.  
  486.  
  487. //---------------------------------------------------------------
  488. //
  489. // ClearBit
  490. //
  491. //---------------------------------------------------------------
  492. void ClearBit(void* bytePtr, ushort bit)
  493. {
  494.     ushort    index = (ushort) (bit >> 3);
  495.     ushort    mask = (Byte) (1 << ((bit & 0x07) ^ 0x07));
  496.  
  497.     ((Byte *) bytePtr)[index] &= (Byte) (~mask);
  498. }
  499.  
  500.  
  501. //---------------------------------------------------------------
  502. //
  503. // InvertBit
  504. //
  505. //---------------------------------------------------------------
  506. void InvertBit(void* bytePtr, ushort bit)
  507. {
  508.     ushort    index = (ushort) (bit >> 3);
  509.     Byte    mask = (Byte) (1 << ((bit & 0x07) ^ 0x07));
  510.  
  511.     ((Byte *) bytePtr)[index] ^= mask;
  512. }
  513.  
  514. #pragma mark -
  515.  
  516. // ===================================================================================
  517. //    Heaps
  518. // ===================================================================================
  519.  
  520. //---------------------------------------------------------------
  521. //
  522. // TemporaryZone
  523. //
  524. //---------------------------------------------------------------
  525. THz TemporaryZone()
  526. {
  527.     OSErr err;
  528.     Handle h = TempNewHandle(1, &err);
  529.     ThrowIfMemFail(h);
  530.         
  531.     THz zone = HandleZone(h);        // MMSystemFreeSpace (in MacApp) sez this can't be cached
  532.     
  533.     DisposeHandle(h);
  534.     
  535.     return zone;
  536. }
  537.  
  538.  
  539. //---------------------------------------------------------------
  540. //
  541. // WalkHeap
  542. //
  543. //---------------------------------------------------------------
  544. #if DEBUG
  545. void WalkHeap(THz zone, HeapWalkerProc callback, void* refCon)
  546. {
  547.     ASSERT(zone != nil);
  548.     ASSERT(zone != TemporaryZone());            // temporary zone header is completely different than all the others...
  549.     ASSERT(callback != nil);
  550.     ASSERT((zone->heapType & kNewStyleHeap) != 0);
  551.                 
  552.     SHeapBlock* blockStart = reinterpret_cast<SHeapBlock*>((Byte*) zone + kZoneHeaderSize);
  553.     ASSERT(blockStart != nil);
  554.  
  555.     SHeapBlock* block = reinterpret_cast<SHeapBlock*>((Byte*) zone + 64)->next;
  556.     ASSERT(block != nil);
  557.     
  558.     while (block >= blockStart) {                // last block points into zone header
  559.         (*callback)(block, refCon);
  560.                 
  561.         block = block->next;    
  562.         ASSERT(block != nil);
  563.     }
  564. }
  565. #endif
  566.  
  567. #pragma mark -
  568.  
  569. // ===================================================================================
  570. //    Unit Test
  571. // ===================================================================================
  572.  
  573. //---------------------------------------------------------------
  574. //
  575. // VerifyBlock
  576. //
  577. //---------------------------------------------------------------
  578. #if DEBUG
  579. static void VerifyBlock(Byte* block, ulong size, Byte value)
  580. {
  581.     Byte* ptr = block;
  582.     for (long i = 0; i < size; i++)
  583.         ASSERT(*ptr++ == value);
  584. }
  585. #endif    // DEBUG
  586.  
  587.  
  588. //---------------------------------------------------------------
  589. //
  590. // TestMemUtils
  591. //
  592. //---------------------------------------------------------------
  593. #if DEBUG
  594. static void TestMemUtils()
  595. {
  596.     Byte block1[100];
  597.     Byte block2[205];
  598.     
  599.     ClearMemory(block1, 100);
  600.     VerifyBlock(block1, 100, 0);
  601.     
  602.     SetMemory(block2, 205, 34);
  603.     VerifyBlock(block2, 34, 205);
  604.     
  605.     InvertMemory(block1, 100);
  606.     VerifyBlock(block1, 100, 0xFF);
  607.     
  608.     ASSERT(!EqualMemory(block1, block2, 100));
  609.     
  610.  
  611.     Handle h = CreateHandle(100, kUseAppHeap + kZeroBytes);
  612.     VerifyBlock((Byte*) *h, 100, 0);
  613.     
  614.     ASSERT(!IsLocked(h));
  615.     ASSERT(!IsPurgeable(h));
  616.     ASSERT(!IsResource(h));
  617.     
  618.     HLock(h);
  619.     ASSERT(IsLocked(h));
  620.     ASSERT(!IsPurgeable(h));
  621.     ASSERT(!IsResource(h));
  622.     
  623.     HPurge(h);
  624.     ASSERT(IsLocked(h));
  625.     ASSERT(IsPurgeable(h));
  626.     ASSERT(!IsResource(h));
  627.     
  628.     DisposeIfHandle(h);
  629.     
  630.     
  631.     h = CreateHandle(100, kUseTempHeap);
  632.     VerifyBlock((Byte*) *h, 100, kNewFill);
  633.     
  634.     ASSERT(!IsLocked(h));
  635.     ASSERT(!IsPurgeable(h));
  636.     ASSERT(!IsResource(h));
  637.     
  638.     HLock(h);
  639.     ASSERT(IsLocked(h));
  640.     ASSERT(!IsPurgeable(h));
  641.     ASSERT(!IsResource(h));
  642.  
  643.     HPurge(h);
  644.     ASSERT(IsLocked(h));
  645.     ASSERT(IsPurgeable(h));
  646.     ASSERT(!IsResource(h));
  647.     
  648.     DisposeIfHandle(h);
  649.     
  650.     
  651.     h = GetResource('SIZE', -1);
  652.     
  653.     ASSERT(!IsLocked(h));
  654.     ASSERT(!IsPurgeable(h));
  655.     ASSERT(IsResource(h));
  656.     
  657.     HLock(h);
  658.     ASSERT(IsLocked(h));
  659.     ASSERT(!IsPurgeable(h));
  660.     ASSERT(IsResource(h));
  661.     
  662.     DetachResource(h);
  663.     ASSERT(IsLocked(h));
  664.     ASSERT(!IsPurgeable(h));
  665.     ASSERT(!IsResource(h));
  666.  
  667.     HPurge(h);
  668.     ASSERT(IsLocked(h));
  669.     ASSERT(IsPurgeable(h));
  670.     ASSERT(!IsResource(h));
  671.     
  672.     DisposeIfHandle(h);
  673.     
  674.         
  675.     TRACE("Completed memory utils test.¥n¥n");
  676. }
  677.  
  678. static TUnitTestRegistrar sMemReg("Memory Utils", TestMemUtils);
  679.  
  680. #endif    // DEBUG
  681.